import { defineStore } from "pinia";
import { ref, onMounted } from "vue";
import socket from "./socket"
import axios from "../axios"
export const useUserStore = defineStore("user", () => {
    let alluser = ref([])        // 存储所有用户信息
    let pendingRequests = ref([])  // 存储未处理的好友请求
    let allFriends = ref([])         // 存储所有好友信息
    let userId = JSON.parse(sessionStorage.getItem("user"))._id   //从sessionStorage中获取当前登录的用户id  发送消息的人
    let acitveUser = ref(JSON.parse(sessionStorage.getItem("activeUser")) || { _id: null })  // 存储当前选中的用户     接收消息的人
    let groupID = ref((JSON.parse(sessionStorage.getItem("groupID"))) || { _id: null })      // 存储当前所在的群组id

    // 控制邀请好友列表显示隐藏
    let flagGroup = ref(false)

    let AllGroupList = ref([])   // 存储所有群聊列表
    let allnotInGroup = ref([])   // 存储不在的该群聊的用户
    let pendingRequestsGroup = ref([])   // 存储未处理的群聊请求

    let messageList = ref([])   // 存储聊天记录

    // 获取所有未添加的用户
    async function getAllUser(value) {  //value是用户名
        const { data: { code, data } } = await axios.post("/getOneUser", { username: value, userID: userId })
        if (code === 200) {
            alluser.value = data
        } else {
            alluser.value = []
        }
        console.log(data)
    }

    // 存储接受消息的好友或群聊信息id到本地
    let saveActiveUser = (item, status) => {
        // 如果status为true 表示单个好友，否则表示群聊
        if (status) {
            sessionStorage.removeItem("groupID");
            sessionStorage.setItem("activeUser", JSON.stringify(item));
            acitveUser.value = item
            groupID.value = { _id: null }
            getmessages()
        } else {
            sessionStorage.removeItem("activeUser");
            sessionStorage.setItem("groupID", JSON.stringify(item));
            groupID.value = item
            acitveUser.value = { _id: null }
            getmessages()
        }
    }

    // 发送好友请求
    async function sendFriendRequest(value) {    //value是用户id
        let { data: { code } } = await axios.post("/sendFriend", { userID: userId, friendID: value })
        if (code === 200) {
            console.log("发送成功");
        } else {
            console.log("已有好友请求或已是好友")
        }
    }

    // 监听来自服务器的好友请求变更
    socket.on("newFriendRequest", (val) => {
        console.log("你收到一条新的好友请求");
        if (val) {
            getPendingFriendRequests()
        }
    })

    // 获取未处理的好友请求
    async function getPendingFriendRequests() {
        const { data: { code, data } } = await axios.post("/getPendingRequests", { userID: userId })
        if (code === 200) {
            // 设置当前用户的未处理好友请求
            pendingRequests.value = data
        } else {
            pendingRequests.value = []
        }
        // console.log("好友申请列表", data)
    }

    // 同意好友请求
    async function acceptFriendRequest(val) {
        let benren = val.friendID
        let duif = val.userID._id
        let listId = val._id
        const { data: { code } } = await axios.post("/acceptFriend", { userID: benren, friendID: duif, requestId: listId })
        if (code === 200) {
            console.log("已经同意该好友申请")
            getPendingFriendRequests()
            getAllFriends()
        }
    }

    // 拒绝好友请求
    async function rejectFriendRequest(val) {
        let benren = val.friendID
        let duif = val.userID._id
        let listId = val._id
        const { data: { code } } = await axios.post("/rejectFriend", { userID: benren, friendID: duif, requestId: listId })
        if (code === 200) {
            console.log("已经拒绝该好友申请")
            getPendingFriendRequests()
            getAllFriends()
        }
    }

    // 监听来之服务器的好友请求处理结果
    socket.on("friendRequestProcessed", (val) => {
        console.log("好友请求已经处理", val)
        // 一旦对方处理了请求，更新当前请求列表,好友列表
        getPendingFriendRequests()
        getAllFriends()
    })

    // 获取所有的好友，存入到好友列表中
    async function getAllFriends() {
        let user = JSON.parse(sessionStorage.getItem("user"))._id
        const { data: { data } } = await axios.post("/getFriends", { userID: user })
        allFriends.value = data
        // console.log("用户好友列表", data)
    }

    // 创建群聊
    async function createGroup(val) {
        let userID = JSON.parse(sessionStorage.getItem("user"))._id
        let newobj = {
            userID,
            name: val,
            members: [userId]
        }
        const { data: { code, data } } = await axios.post("/createGroup", newobj)
        if (code === 200) {
            getGroupslist()
        }
    }

    // 获取用户所在群聊以及创建的群聊
    async function getGroupslist() {
        let userID = JSON.parse(sessionStorage.getItem("user"))._id
        let { data: { data, code } } = await axios.post("/getGroups", { userID })
        if (code === 200) {
            AllGroupList.value = data;
        }
    }

    // 邀请好友进入群聊
    async function sendFriendToGroup(val) {
        let obj = {
            userID: userId,
            groupID: groupID.value._id,
            friendID: val
        }
        let { data: { code, msg } } = await axios.post("/sendFriendToGroup", obj)
        if (code === 200) {
            flagGroup.value = false;
        }
        console.log(code, msg)
    }

    // 用户或好友同意或拒绝加入群聊
    async function respondToGroupInvite(val, status) {
        let newobj = {
            inviteID: val._id,
            userID: val.friendID,
            status: status
        }
        let { data: { code, data } } = await axios.post("/respondToGroupInvite", newobj)
        if (code === 200) {
            getPendingGroupInvites()
        }
    }

    // 监听来自服务器的群聊邀请请求变更
    socket.on("newGroupInvite", (val) => {
        console.log("你收到一条新的群聊邀请");
        if (val) {
            getPendingGroupInvites()
        }
    })

    // 监听群聊加入成功
    socket.on("groupInviteSuccess", (data) => {
        getGroupslist()
    });

    // 发送给所有该群聊在线的用户，使其更新
    socket.on("newGroupMember", (val) => {
        if (val) {
            getGroupslist()
        }
    })


    // 获取未处理的群聊请求
    async function getPendingGroupInvites() {
        let { data: { code, data } } = await axios.post("/getPendingGroupInvites", { userID: userId })
        if (code === 200) {
            pendingRequestsGroup.value = data;
        }
    }

    // 获取所有未在该群的用户
    async function getGroupMembers() {
        let groupID = JSON.parse(sessionStorage.getItem("groupID"))._id || null
        if (!groupID) {
            alert("请选择群聊")
            return
        }
        const { data: { data, code } } = await axios.post("/getGroupMembers", { groupID })
        if (code === 200) {
            allnotInGroup.value = data;
            flagGroup.value = !flagGroup.value;
        }
    }

    // 修改flagGroup的显示隐藏
    function changeFlagGroup() {
        flagGroup.value = !flagGroup.value
    }

    // 发送消息到后端
    async function sendAllmessage(val, type) {
        if (!acitveUser && !groupID) {
            console.log("请选择接收者")
            return
        }
        let content
        if (type === 0) {
            content = val
        }
        if (type === 1) {
            content = `<img src="/emot/${val}" width="150px" height="150px" alt="图片">`
        }
        let newobj = {
            sender_id: userId,           //发送者id
            receive_id: acitveUser.value._id,      //接收者id
            group_id: groupID.value._id,           //群组id
            content: content,            //消息内容
            context_type: type,             //消息类型 0:文本 1:表情包
            media_url: null,             //图片链接
            is_group_message: groupID.value._id ? true : false,    //是否为群消息
        }
        // 发送消息
        socket.emit("sendMessage", newobj);
        getmessages()
    }

    // 获取聊天的消息
    async function getmessages() {
        if (!groupID.value._id && !acitveUser.value._id) {
            console.log("请选择聊天对象")
            return
        }
        let newobj = {
            user_id: userId,
            group_id: groupID.value._id,
            receiver_id: acitveUser.value._id,
        }
        let { data: { code, data } } = await axios.post("/getmessages", newobj)
        console.log(data)
        if (code === 200) {
            messageList.value = data
        }
    }

    // 监听接收到的消息
    socket.on("receiveMessage", (message) => {
        getmessages()
    });

    // 在组件挂载时调用获取未处理请求的接口
    onMounted(() => {
        getPendingFriendRequests()   //用户上线时，加载未处理的请求
        getAllFriends()             //用户上线时，加载好友列表
        getGroupslist()             //用户上线时，加载群聊列表
        getPendingGroupInvites()    //用户上线时，加载未处理的群聊邀请
        getmessages()              //用户上线时，加载聊天消息
    })

    return {
        alluser, pendingRequests, allFriends, acitveUser, AllGroupList, groupID, allnotInGroup, flagGroup, pendingRequestsGroup, messageList,
        getAllUser, sendFriendRequest,
        acceptFriendRequest, //同意好友请求
        rejectFriendRequest, //拒绝好友请求
        sendAllmessage,      //发送全部类型消息
        saveActiveUser,      //存储当前选中的用户id
        createGroup,         //创建群聊
        sendFriendToGroup,   //邀请好友进入群聊
        getGroupMembers,     //获取未加入群聊成员列表
        changeFlagGroup,     //修改flagGroup的显示隐藏
        respondToGroupInvite,//用户或好友同意或拒绝加入群聊
    }
});